#pragma once
#include <iostream>
#include <string>
#include <jsoncpp/json/json.h>
using namespace std;

// 模拟定协议
// 1.实现结构数据的序列化和反序列化
// 2.解决报文边界的问题

// #define Self_define 1 // 通过Json实现序列化与反序列化

const string sepa = " ";
const string line_break = "\n";

// 添加报头数据和解报头
void Encode(string &mes)
{
    int len = mes.size();
    string ret = to_string(len) + line_break + mes + line_break;
    mes = ret;
}

bool Decode(string &package, string &ret)
{
    //"len\n123 wuwu\n"
    // 先判断收到的数据是否完整
    int len = package.size();
    int pos = package.find(line_break); // 指向第一个换行符
    if (pos == string::npos)
        return false;

    int pos1 = package.find(line_break, pos + line_break.size()); // 指向第二个换行符
    if (pos1 == string::npos)
        return false;

    // 解包后的数据
    ret = package.substr(pos + line_break.size(), pos1 - pos - 1);
    // 去掉被读走的数据
    package = package.substr(pos1 + line_break.size());

    return true;
}

class Request
{
    friend class Cal;

public:
    Request() {}
    Request(int x, int y, char op)
        : _x(x), _y(y), _oper(op)
    {
    }

    void info()
    {
        cout << _x << ' ' << _oper << ' ' << _y << " = ?" << endl;
    }

    void Serialize(string &out) // 序列化
    {
#ifdef Self_define
        out = to_string(_x) + sepa + _oper + sepa + to_string(_y);
#else
        Json::Value root;
        root["_x"] = _x;
        root["_y"] = _y;
        root["_oper"] = _oper;

        Json::FastWriter writer;
        out = writer.write(root);
#endif
    }
    //"x + y"
    void Deserialize(const string s) // 反序列化
    {
#ifdef Self_define
        int begin = 0;
        int end = s.find(sepa, begin);
        _x = stoi(s.substr(begin, end - begin));
        begin = end + sepa.size(); // 加的1其实就是' '的长度

        end = s.find(sepa, begin);
        _oper = s.substr(begin, end - begin)[0];
        begin = end + sepa.size();

        _y = stoi(s.substr(begin));
#else
        Json::Value root;
        Json::Reader reader;
        bool ret = reader.parse(s,root);//调用反序列化方法，将序列化的数据s反序列到root里
        if(ret)//解析root
        {
            _x = root["_x"].asInt();
            _y = root["_y"].asInt();
            _oper = root["_oper"].asInt();
        }
#endif
    }

private:
    int _x;
    int _y;
    char _oper;
};

class Response
{
public:
    Response()
    {
    }
    Response(int re, string ret_info)
        : _result(re), _ret_info(ret_info)
    {
    }
    void Info()
    {
        cout << "result = " << _result << " (" << _ret_info << ')' << endl;
    }

    void Serialize(string &out) // 序列化
    {
#ifdef Self_define
        out = to_string(_result) + sepa + _ret_info;
#else
        Json::Value root;
        root["_result"] = _result;
        root["_ret_info"] = _ret_info;

        Json::FastWriter writer;
        out = writer.write(root);
#endif
    }
    //"_result _ret_info"
    void Deserialize(const string s) // 反序列化
    {
#ifdef Self_define
        int begin = 0;
        int end = s.find(sepa, begin);
        _result = stoi(s.substr(begin, end - begin));
        begin = end + sepa.size(); // 加的1其实就是分隔符的长度

        _ret_info = s.substr(begin);
#else
        Json::Value root;
        Json::Reader reader;
        bool ret = reader.parse(s,root);//调用反序列化方法，将序列化的数据s反序列到root里
        if(ret)//解析root
        {
            _result = root["_result"].asInt();
            _ret_info = root["_ret_info"].asString();//会导致读取取出错而直接崩溃
        }

#endif
    }

private:
    int _result;      // 保存结果
    string _ret_info; // 结果信息
};